home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / dev / misc / vahunz.lha / vahunz / source / ugly / umemory.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-19  |  7.9 KB  |  485 lines
  1. /*
  2.  * This source file is part of Vahunz,
  3.  * a tool to make source code un-/more legible.
  4.  *
  5.  *--------------------------------------------------------------------------
  6.  *
  7.  * Vahunz and the Ugly library are Copyright (C) 1998 by
  8.  * Thomas Aglassinger <agi@giga.or.at>
  9.  *
  10.  * All rights reserved.
  11.  *
  12.  * Refer to the manual for more information.
  13.  *
  14.  *--------------------------------------------------------------------------
  15.  *
  16.  * Ubiqx library is Copyright (C) 1991-1998 by
  17.  * Christopher R. Hertel <crh@ubiqx.mn.org>
  18.  *
  19.  * Ubiqx library is free software; you can redistribute it and/or
  20.  * modify it under the terms of the GNU Library General Public
  21.  * License as published by the Free Software Foundation; either
  22.  * version 2 of the License, or (at your option) any later version.
  23.  *
  24.  */
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include <string.h>
  28. #include "utypes.h"
  29. #define e8U
  30. #include "umemory.h"
  31. #define a2C 16
  32. #if defined(AMIGA)
  33. #define d7J 8 
  34. #else
  35. #define d7J 8
  36. #endif
  37. #ifndef c4M
  38. #define c4M(x,by) ((by)*(((x)+(by-1))/(by)))
  39. #endif
  40. static s4Q *x3B = NULL;
  41. static UBYTE z7P[4] =
  42. {0xDE, 0xAD, 0xBE, 0xEF}; 
  43. static UBYTE m2Ep[4] =
  44. {0xDE, 0xAD, 0xF0, 0x0D}; 
  45. static UBYTE z1X = 0x81;
  46. static ULONG g4A = 0; 
  47. static ULONG m6W = 0; 
  48. static ULONG f9Dw = 0; 
  49. static ULONG d3T = 0; 
  50. static ULONG a2Wl = 0; 
  51. static ULONG e6O = 0; 
  52. static ULONG t1L = 0; 
  53. static ULONG u4U = 0; 
  54. static ULONG w0S = 0; 
  55. static ULONG v3V = 0; 
  56. void *q4E(size_t u0Qh);
  57. static BOOL p1L(s4Q * l1Pu);
  58. BOOL(*k0Cr) (size_t u0Qh) = NULL;
  59. VOID i0Y(char *msg, char *j5R, size_t q6U)
  60. {
  61. fprintf(stderr, "\n\n");
  62. fprintf(stderr, "  I won't be a monkey in anyone's zoo\n");
  63. fprintf(stderr, "  I won't get fazed whatever you do\n");
  64. fprintf(stderr, "                   (Ride, \"Not Fazed\")\n\n");
  65. fprintf(stderr, "** internal error: \"%s\" (%lu): %s\n", \
  66. j5R, (unsigned long) q6U, msg);
  67. exit(255);
  68. }
  69. static s4Q *r5T(void *mem)
  70. {
  71. s4Q *q8Gz = x3B;
  72. s4Q *y0O = NULL;
  73. while (q8Gz && (!y0O))
  74. {
  75. if (q8Gz->ptr == mem)
  76. {
  77. y0O = q8Gz;
  78. }
  79. q8Gz = q8Gz->z7X;
  80. }
  81. #if c6K==2
  82. if (!y0O)
  83. {
  84. fprintf(stderr, "*memory* FIND_UMEM: couln't find %p\n", mem);
  85. }
  86. #endif
  87. return (y0O);
  88. }
  89. static s4Q *h1Z(s4Q * l1Pu)
  90. {
  91. s4Q *prev = x3B;
  92. s4Q *p9B = NULL;
  93. BOOL y0O = FALSE;
  94. while (prev && (!y0O))
  95. {
  96. y0O = (prev == l1Pu);
  97. if (!y0O)
  98. {
  99. p9B = prev;
  100. prev = prev->z7X;
  101. }
  102. }
  103. return (p9B);
  104. }
  105. static void v9X(void *mem, size_t u0Qh, UBYTE value[4])
  106. {
  107. size_t i;
  108. for (i = 0; i < u0Qh; i++)
  109. {
  110. (((UBYTE *) mem)[i]) = value[i % 4];
  111. }
  112. }
  113. static void f1By(void *mem, size_t u0Qh, UBYTE value)
  114. {
  115. size_t i;
  116. for (i = 0; i < u0Qh; i++)
  117. {
  118. (((UBYTE *) mem)[i]) = value;
  119. }
  120. }
  121. static void r7X(s4Q * l1Pu)
  122. {
  123. s4Q *prev = h1Z(l1Pu);
  124. if (prev)
  125. {
  126. prev->z7X = l1Pu->z7X;
  127. }
  128. else
  129. {
  130. x3B = l1Pu->z7X;
  131. }
  132. if (!p1L(l1Pu))
  133. {
  134. v9X(l1Pu->j7R, l1Pu->u0Qh + 2 * a2C, z7P);
  135. free(l1Pu->j7R);
  136. }
  137. l1Pu->j7R = NULL;
  138. l1Pu->m6S = NULL;
  139. l1Pu->u0Qh = 0;
  140. l1Pu->j5R = NULL;
  141. l1Pu->q6U = 0;
  142. free(l1Pu);
  143. }
  144. static s4Q *o8O(size_t p1Bk, STRPTR b1J, ULONG o6O)
  145. {
  146. s4Q *w6U = (s4Q *) malloc(sizeof(s4Q));
  147. if (w6U)
  148. {
  149. w6U->j7R = (UBYTE *) q4E(p1Bk
  150. + 2 * a2C);
  151. if (w6U->j7R)
  152. {
  153. w6U->ptr = (void *) (w6U->j7R + a2C);
  154. w6U->m6S = (w6U->j7R + a2C + p1Bk);
  155. w6U->z7X = x3B;
  156. x3B = w6U;
  157. w6U->u0Qh = p1Bk;
  158. w6U->j5R = b1J;
  159. w6U->q6U = o6O;
  160. w6U->c2G = z1X;
  161. v9X(w6U->ptr, p1Bk, m2Ep);
  162. f1By(w6U->j7R, a2C, z1X);
  163. f1By(w6U->m6S, a2C, z1X);
  164. if (z1X == 0xff)
  165. {
  166. z1X = 0x81;
  167. }
  168. else
  169. {
  170. z1X++;
  171. }
  172. }
  173. else
  174. free(w6U);
  175. }
  176. return (w6U);
  177. }
  178. static void u4C(STRPTR msg)
  179. {
  180. fprintf(stderr, "%s\n", msg);
  181. }
  182. static void d1T(void *ptr, size_t u0Qh)
  183. {
  184. unsigned char *data = (unsigned char *) ptr;
  185. if (u0Qh > 16)
  186. {
  187. u0Qh = 16;
  188. }
  189. fprintf(stderr, "  %p:", ptr);
  190. if (data)
  191. {
  192. size_t i;
  193. for (i = 0; i < u0Qh; i++)
  194. {
  195. if (!(i % 4))
  196. {
  197. fprintf(stderr, " ");
  198. }
  199. fprintf(stderr, "%02x", data[i]);
  200. }
  201. while (i < 16)
  202. {
  203. if (!(i % 4))
  204. {
  205. fprintf(stderr, " ");
  206. }
  207. fprintf(stderr, "  ");
  208. i++;
  209. }
  210. fprintf(stderr, "  \"");
  211. for (i = 0; i < u0Qh; i++)
  212. {
  213. if (data[i] < ' ' || ((data[i] > 128) && (data[i] < 160)))
  214. {
  215. fprintf(stderr, ".");
  216. }
  217. else
  218. {
  219. fprintf(stderr, "%c", data[i]);
  220. }
  221. }
  222. fprintf(stderr, "\"\n");
  223. }
  224. else
  225. fprintf(stderr, "NULL\n");
  226. }
  227. static void b3R(void *ptr, STRPTR j5R, ULONG q6U)
  228. {
  229. fprintf(stderr, "  %p: from \"%s\" (%lu)\n", ptr, j5R, q6U);
  230. }
  231. static void b7D(s4Q * l1Pu)
  232. {
  233. fprintf(stderr, "  %p: %lu (0x%lx) bytes from \"%s\" (%lu)\n",
  234. l1Pu->ptr, (ULONG) l1Pu->u0Qh, (ULONG) l1Pu->u0Qh,
  235. l1Pu->j5R, l1Pu->q6U);
  236. }
  237. static STRPTR a2M(UBYTE p5X)
  238. {
  239. static z5N j9Z[30];
  240. UBYTE ch = p5X;
  241. if (ch < 32)
  242. ch = '.';
  243. sprintf(j9Z, "(0x%02x/#%d/`%c')", p5X, p5X, ch);
  244. return (j9Z);
  245. }
  246. static BOOL p1L(s4Q * l1Pu)
  247. {
  248. size_t i = 0;
  249. BOOL t1Jq = FALSE;
  250. while (!t1Jq && (i < a2C))
  251. {
  252. BOOL m4Q = (l1Pu->j7R[i] != l1Pu->c2G);
  253. BOOL h3F = (l1Pu->m6S[i] != l1Pu->c2G);
  254. t1Jq = m4Q || h3F;
  255. if (t1Jq)
  256. {
  257. STRPTR c8M;
  258. UBYTE value;
  259. if (m4Q)
  260. {
  261. c8M = "LOWER";
  262. value = l1Pu->j7R[i];
  263. }
  264. else
  265. {
  266. c8M = "UPPER";
  267. value = l1Pu->m6S[i];
  268. }
  269. fprintf(stderr, "*** MEMORY WALL DAMAGED!!!\n");
  270. fprintf(stderr, "*** %s wall, byte#%lu is %s instead of 0x%02x\n",
  271. c8M, (ULONG) i, a2M(value), l1Pu->c2G);
  272. b7D(l1Pu);
  273. d1T(l1Pu->ptr, l1Pu->u0Qh);
  274. fprintf(stderr, "  * lower wall:\n");
  275. d1T(l1Pu->j7R, a2C);
  276. fprintf(stderr, "  * upper wall:\n");
  277. d1T(l1Pu->m6S, a2C);
  278. }
  279. else
  280. {
  281. i++;
  282. }
  283. }
  284. return (t1Jq);
  285. }
  286. VOID b9D(STRPTR msg, STRPTR j5R, ULONG q6U)
  287. {
  288. s4Q *l1Pu = x3B;
  289. if (l1Pu)
  290. {
  291. fprintf(stderr, "MEMORY WALL-CHECK (%s)", msg);
  292. if (j5R)
  293. fprintf(stderr, " from `%s' (%lu)", j5R, q6U);
  294. fprintf(stderr, "\n");
  295. while (l1Pu)
  296. {
  297. if (l1Pu->ptr)
  298. {
  299. p1L(l1Pu);
  300. l1Pu = l1Pu->z7X;
  301. }
  302. else
  303. {
  304. l1Pu = NULL;
  305. fprintf(stderr, "\n** PANIC: memory list trashed\n");
  306. }
  307. }
  308. }
  309. }
  310. void l5Z(STRPTR msg, STRPTR j5R, ULONG q6U, STRPTR date, STRPTR time)
  311. {
  312. s4Q *l1Pu = x3B;
  313. if (l1Pu)
  314. {
  315. fprintf(stderr, "MEMORY REPORT (%s)\n", msg);
  316. if (j5R)
  317. {
  318. fprintf(stderr, "(\"%s\" (%lu), at %s, %s)\n",
  319. j5R, q6U, date, time);
  320. }
  321. while (l1Pu)
  322. {
  323. if (l1Pu->ptr)
  324. {
  325. b7D(l1Pu);
  326. d1T(l1Pu->ptr, l1Pu->u0Qh);
  327. l1Pu = l1Pu->z7X;
  328. }
  329. else
  330. {
  331. l1Pu = NULL;
  332. fprintf(stderr, "##\n## panic: memory list trashed\n##\n");
  333. }
  334. }
  335. }
  336. }
  337. void q4M(STRPTR msg, STRPTR j5R, ULONG q6U, STRPTR date, STRPTR time)
  338. {
  339. fprintf(stderr, "MEMORY STATISTICS (%s)\n", msg);
  340. if (j5R)
  341. {
  342. fprintf(stderr, "(\"%s\" (%lu), at %s, %s)\n",
  343. j5R, q6U, date, time);
  344. }
  345. fprintf(stderr, "  bytes used: %lu max: %lu/%lu  ",
  346. e6O, t1L,
  347. a2Wl);
  348. if (a2Wl)
  349. {
  350. fprintf(stderr, "slack: %lu%%\n",
  351. (100 * (t1L - a2Wl))
  352. / a2Wl);
  353. }
  354. else
  355. {
  356. fprintf(stderr, "no slack\n");
  357. }
  358. fprintf(stderr, "  nodes used: %lu (max: %lu)\n",
  359. v3V, w0S);
  360. fprintf(stderr, "  calls to: umalloc(%lu)   ufree(%lu)\n",
  361. g4A, m6W);
  362. }
  363. void d3V(void)
  364. {
  365. ULONG c0O = e6O;
  366. l5Z("at exit:  MEMORY LEAK detected!",
  367. NULL, 0, NULL, NULL);
  368. q4M("[exit]", NULL, 0, NULL, NULL);
  369. while (x3B)
  370. {
  371. r7X(x3B);
  372. }
  373. if (c0O)
  374. {
  375. fprintf(stderr, "\n%lu bytes of memory lost!\n", c0O);
  376. }
  377. }
  378. void q8G(void)
  379. {
  380. }
  381. void *q4E(size_t u0Qh)
  382. {
  383. void *mem;
  384. BOOL m6Q;
  385. do
  386. {
  387. mem = malloc(u0Qh);
  388. if (!mem && k0Cr)
  389. {
  390. m6Q = (*k0Cr) (u0Qh);
  391. if (!m6Q)
  392. {
  393. exit(EXIT_FAILURE); 
  394. }
  395. }
  396. else
  397. {
  398. m6Q = FALSE;
  399. }
  400. }
  401. while (m6Q);
  402. return (mem);
  403. }
  404. void *n3V(size_t u0Qh, STRPTR j5R, ULONG q6U)
  405. {
  406. void *mem = NULL;
  407. s4Q *l1Pu = NULL;
  408. #if c6K==2
  409. fprintf(stderr, "*memory* UMALLOC() from `%s' (%lu)\n", j5R, q6U);
  410. #endif
  411. if (u0Qh)
  412. {
  413. g4A++;
  414. l1Pu = o8O(u0Qh, j5R, q6U);
  415. if (l1Pu)
  416. {
  417. mem = l1Pu->ptr;
  418. e6O += u0Qh;
  419. u4U += c4M(u0Qh, d7J);
  420. if (e6O > a2Wl)
  421. a2Wl = e6O;
  422. if (u4U > t1L)
  423. t1L = u4U;
  424. v3V++;
  425. if (v3V > w0S)
  426. w0S = v3V;
  427. }
  428. }
  429. else
  430. {
  431. f9Dw++;
  432. u4C("MALLOC: zero-sized allocation");
  433. b3R(NULL, j5R, q6U);
  434. }
  435. return (mem);
  436. }
  437. void u6K(void *ptr, STRPTR j5R, ULONG q6U)
  438. {
  439. #if c6K==2
  440. fprintf(stderr, "*memory* UFREE() from `%s' (%lu)\n", j5R, q6U);
  441. #elif 0
  442. fputc('.', stderr); 
  443. fflush(stderr);
  444. #endif
  445. if (ptr)
  446. {
  447. s4Q *l1Pu = r5T(ptr);
  448. if (l1Pu)
  449. {
  450. m6W++;
  451. e6O -= l1Pu->u0Qh;
  452. u4U -= c4M(l1Pu->u0Qh, d7J);
  453. r7X(l1Pu);
  454. v3V--;
  455. }
  456. else
  457. {
  458. d3T++;
  459. u4C("*** FREE: memory never allocated "
  460. " or released twice");
  461. b3R(ptr, j5R, q6U);
  462. }
  463. }
  464. }
  465. void *g0Cd(void *ptr, size_t u0Qh, STRPTR j5R, ULONG q6U)
  466. {
  467. void *o2O = n3V(u0Qh, j5R, q6U);
  468. s4Q *l1Pu = r5T(ptr);
  469. if (o2O && l1Pu)
  470. {
  471. memcpy(o2O, l1Pu->ptr, l1Pu->u0Qh);
  472. u6K(ptr, j5R, q6U);
  473. }
  474. return (o2O);
  475. }
  476. void *i4I(size_t count, size_t u0Qh, STRPTR j5R, ULONG q6U)
  477. {
  478. void *mem = n3V(count * u0Qh, j5R, q6U);
  479. if (mem)
  480. {
  481. memset(mem, 0, u0Qh * count);
  482. }
  483. return (mem);
  484. }
  485.